home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / usenet / volume4 / nobs2 < prev    next >
Encoding:
Internet Message Format  |  1988-05-20  |  38.8 KB
  1. Path: uunet!husc6!bloom-beacon!mit-eddie!uw-beaver!tektronix!tekgen!tekred!games
  2. From: games@tekred.TEK.COM
  3. Newsgroups: comp.sources.games
  4. Subject: v04i013:  nobs2 - updated version of nobs cribbage game
  5. Keywords: cribbage game
  6. Message-ID: <2541@tekred.TEK.COM>
  7. Date: 20 May 88 22:28:21 GMT
  8. Sender: billr@tekred.TEK.COM
  9. Lines: 1683
  10. Approved: billr@saab.CNA.TEK.COM
  11.  
  12. Submitted by: ihnp4!odyssey!gls (g.l.sicherman)
  13. Comp.sources.games: Volume 4, Issue 13
  14. Archive-name: nobs2
  15.  
  16.     [This is an update of a previously posted nobs game
  17.      (v04i002). -br]
  18.  
  19. #! /bin/sh
  20. # This is a shell archive.  Remove anything before this line, then unpack
  21. # it by saving it into a file and typing "sh file".  To overwrite existing
  22. # files, type "sh file -c".  You can also feed this as standard input via
  23. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  24. # will see the following message at the end:
  25. #        "End of archive 1 (of 1)."
  26. # Contents:  README MANIFEST Makefile deal.c defs.h gamescore.c globs.c
  27. #   globs.h human.c logaux.c logglobs.c logglobs.h nobs.6 nobs.c
  28. #   pegs.c play.c playscore.c progaux.c program.c show.c shuf.c
  29. #   version.c wglobs.c window.c window.h
  30. # Wrapped by billr@saab on Fri May 20 14:55:12 1988
  31. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  32. if test -f README -a "${1}" != "-c" ; then 
  33.   echo shar: Will not over-write existing file \"README\"
  34. else
  35. echo shar: Extracting \"README\" \(1088 characters\)
  36. sed "s/^X//" >README <<'END_OF_README'
  37. X    This is C version 1.1 of the Colonel's Cribbage
  38. XProgram.  (It originally ran in FORTRAN IV on a CDC,
  39. Xback in the 70's.)  Cribbage is a card game invented
  40. Xby Sir John Suckling (1609-1642), and if you don't know
  41. Xthe rules, this program will either delight you or
  42. Xgive you a headache, depending on your temperament.
  43. X
  44. X    Changes from version 1.0:
  45. X
  46. X1. Add -h option.
  47. X2. Refine discard algorithm to agree with the original.
  48. X3. Fix and tweak screen interface bugs.
  49. X4. Fix bug in scoring pairs of aces.
  50. X5. Add O.S. and related configuration options to Makefile.
  51. X
  52. X    All configurables are in the Makefile.  Besides the
  53. XOS dependencies, there are two installation options:
  54. X
  55. X1. Suppress the -h (hint) command-line option.
  56. X2. Use 'g' instead of carriage-return when discarding.
  57. X
  58. XIf you run under Xenix, you will probably need option 2.
  59. XThis release works under Ultrix; the previous release did
  60. Xnot.
  61. X
  62. X    As before, feed back to ihnp4!odyssey!gls.  Bug reports
  63. Xare welcome.  Suggestions for enhancements may be welcome,
  64. Xbut bells and whistles would be out of place.
  65. X
  66. XRed Hill Road
  67. XApril 9, 1988
  68. END_OF_README
  69. if test 1088 -ne `wc -c <README`; then
  70.     echo shar: \"README\" unpacked with wrong size!
  71. fi
  72. # end of overwriting check
  73. fi
  74. if test -f MANIFEST -a "${1}" != "-c" ; then 
  75.   echo shar: Will not over-write existing file \"MANIFEST\"
  76. else
  77. echo shar: Extracting \"MANIFEST\" \(864 characters\)
  78. sed "s/^X//" >MANIFEST <<'END_OF_MANIFEST'
  79. X   File Name        Archive #    Description
  80. X-----------------------------------------------------------
  81. X MANIFEST                  1    This shipping list
  82. X Makefile                  1    
  83. X README                    1    
  84. X deal.c                    1    
  85. X defs.h                    1    
  86. X gamescore.c               1    
  87. X globs.c                   1    
  88. X globs.h                   1    
  89. X human.c                   1    
  90. X logaux.c                  1    
  91. X logglobs.c                1    
  92. X logglobs.h                1    
  93. X nobs.6                    1    
  94. X nobs.c                    1    
  95. X pegs.c                    1    
  96. X play.c                    1    
  97. X playscore.c               1    
  98. X progaux.c                 1    
  99. X program.c                 1    
  100. X show.c                    1    
  101. X shuf.c                    1    
  102. X version.c                 1    
  103. X wglobs.c                  1    
  104. X window.c                  1    
  105. X window.h                  1    
  106. END_OF_MANIFEST
  107. if test 864 -ne `wc -c <MANIFEST`; then
  108.     echo shar: \"MANIFEST\" unpacked with wrong size!
  109. fi
  110. # end of overwriting check
  111. fi
  112. if test -f Makefile -a "${1}" != "-c" ; then 
  113.   echo shar: Will not over-write existing file \"Makefile\"
  114. else
  115. echo shar: Extracting \"Makefile\" \(1757 characters\)
  116. sed "s/^X//" >Makefile <<'END_OF_Makefile'
  117. X#    Makefile for nobs.
  118. X#    G. L. Sicherman (ihnp4!odyssey!gls).  March 1988.  April 1988.
  119. X#    BSD fixes by saab!billr.
  120. X#    Xenix fixes by 1solaria!gordon.
  121. X#-------
  122. X# CONFIGURABLE PARAMETERS:
  123. X
  124. X# Define destinations for executable and manpage:
  125. XBINDEST=$$HOME/bin/nobs
  126. XMANDEST=$$HOME/man/nobs.6
  127. X
  128. X# Define BSD for Berkeley, Sun, Xenix, etc.
  129. X# BSDFLAG= -DBSD
  130. XBSDFLAG=
  131. X
  132. X# Define FLOAT for systems that need a floating-point
  133. X# interpreter linked in.  (3b5, Unix(TM) PC (?), etc.)
  134. X# FLOAT= -f
  135. XFLOAT=
  136. X
  137. X# If BSD or Xenix, you need -ltermcap.
  138. X# If Xenix, you need -lx.
  139. X# LIB= -lcurses -ltermcap -lx
  140. XLIB= -lcurses
  141. X
  142. X# If Xenix, you need -Mm and -F 2000.
  143. X# XFLGS= -Mm -F 2000
  144. XXFLGS=
  145. X
  146. X# Define NOHINT to disable the -h option.
  147. X# NOHINTFLAG= -DNOHINT
  148. XNOHINTFLAG= 
  149. X
  150. X# Define GDISC to discard with 'g' instead of CR.
  151. X# GDISCFLAG= -DGDISC
  152. XGDISCFLAG=
  153. X
  154. X# End of configurable parameters.  Good luck!
  155. X
  156. XCFLAGS= -O $(BSDFLAG) $(FLOAT) $(XFLGS) $(GDISCFLAG) $(NOHINTFLAG)
  157. X
  158. XOBJS = nobs.o logglobs.o window.o gamescore.o deal.o shuf.o play.o human.o \
  159. X   pegs.o program.o playscore.o show.o progaux.o logaux.o wglobs.o globs.o \
  160. X   version.o
  161. X
  162. XSHARS = nobs.c logglobs.c window.c gamescore.c deal.c shuf.c play.c human.c \
  163. X   pegs.c program.c playscore.c show.c progaux.c logaux.c wglobs.c \
  164. X   globs.c version.c defs.h globs.h logglobs.h window.h nobs.6 Makefile README
  165. X
  166. Xall: nobs
  167. Xnobs: $(OBJS)
  168. X    cc $(CFLAGS) -o nobs $(OBJS) $(LIB)
  169. X$(OBJS): defs.h globs.h
  170. Xlog.o progaux.o program.o: logglobs.h
  171. Xplay.o program.o human.o gamescore.o pegs.o window.o show.o: window.h
  172. X
  173. Xinstall: nobs nobs.6
  174. X    rm -f $(BINDEST) $(MANDEST)
  175. X    cp nobs $(BINDEST)
  176. X    echo ".ds nh $(NOHINTFLAG)" > $(MANDEST)
  177. X    cat nobs.6 >> $(MANDEST)
  178. X
  179. Xshar: nobs.shar
  180. Xnobs.shar: $(SHARS)
  181. X    shar $(SHARS) > $@
  182. X
  183. Xclean:
  184. X    rm -f nobs *.o nobs.shar
  185. END_OF_Makefile
  186. if test 1757 -ne `wc -c <Makefile`; then
  187.     echo shar: \"Makefile\" unpacked with wrong size!
  188. fi
  189. # end of overwriting check
  190. fi
  191. if test -f deal.c -a "${1}" != "-c" ; then 
  192.   echo shar: Will not over-write existing file \"deal.c\"
  193. else
  194. echo shar: Extracting \"deal.c\" \(218 characters\)
  195. sed "s/^X//" >deal.c <<'END_OF_deal.c'
  196. X#include "defs.h"
  197. X#include "globs.h"
  198. X
  199. Xdeal()
  200. X{
  201. X    int i;
  202. X    CARD *packp;
  203. X    shuf();
  204. X    packp = pack+39;    /* Only the last 13 cards */
  205. X    for (i=0; i<6; i++) {
  206. X        hand[0][i] = *packp++;
  207. X        hand[1][i] = *packp++;
  208. X    }
  209. X    cut = *packp;
  210. X}
  211. END_OF_deal.c
  212. if test 218 -ne `wc -c <deal.c`; then
  213.     echo shar: \"deal.c\" unpacked with wrong size!
  214. fi
  215. # end of overwriting check
  216. fi
  217. if test -f defs.h -a "${1}" != "-c" ; then 
  218.   echo shar: Will not over-write existing file \"defs.h\"
  219. else
  220. echo shar: Extracting \"defs.h\" \(726 characters\)
  221. sed "s/^X//" >defs.h <<'END_OF_defs.h'
  222. X/*
  223. X *    defs.h - definitions.
  224. X */
  225. X
  226. X/*    Suit has 3 bits, so we can use the green suit for estimating the cut.
  227. X */
  228. X#define RANK(x) ((x)&0017)
  229. X#define    SUIT(x) (((x)&0160)>>4)
  230. X#define    SAMERANK(x,y) (!((x^y)&0017))
  231. X#define    SAMESUIT(x,y) (!((x^y)&0160))
  232. X#define    MAKECARD(r,s) ((r)|((s)<<4))
  233. X
  234. Xtypedef    char    PLAYER;
  235. X
  236. X#define    PROGRAM    0
  237. X#define    HUMAN    1
  238. X
  239. X#define    SCOREUP(a,b) {if (scoreup((a),(b))) {gameover++; return;}}
  240. X#define    CABBAGE    4
  241. X#define    SPADE    3
  242. X#define    HEART    2
  243. X#define    DIAMOND    1
  244. X#define    CLUB    0
  245. X
  246. X#define    KING    13
  247. X#define    QUEEN    12
  248. X#define    KNAVE    11
  249. X#define    TEN    10
  250. X#define    NINE    9
  251. X#define    EIGHT    8
  252. X#define    SEVEN    7
  253. X#define    SIX    6
  254. X#define    FIVE    5
  255. X#define    FOUR    4
  256. X#define    TREY    3
  257. X#define    DEUCE    2
  258. X#define    ACE    1
  259. X
  260. Xtypedef    char    CARD;
  261. X
  262. Xvoid    shuf();
  263. END_OF_defs.h
  264. if test 726 -ne `wc -c <defs.h`; then
  265.     echo shar: \"defs.h\" unpacked with wrong size!
  266. fi
  267. # end of overwriting check
  268. fi
  269. if test -f gamescore.c -a "${1}" != "-c" ; then 
  270.   echo shar: Will not over-write existing file \"gamescore.c\"
  271. else
  272. echo shar: Extracting \"gamescore.c\" \(3455 characters\)
  273. sed "s/^X//" >gamescore.c <<'END_OF_gamescore.c'
  274. X#include "defs.h"
  275. X#include "globs.h"
  276. X#include "window.h"
  277. X
  278. Xgamescore()
  279. X{
  280. X    sleep(2);
  281. X    handscore(!dealer);
  282. X    if (!gameover) {
  283. X        sleep(2);
  284. X        handscore(dealer);
  285. X    }
  286. X    if (!gameover) {
  287. X        sleep(1);
  288. X        werase(Pscore);
  289. X        werase(Hscore);
  290. X        exposecrib();
  291. X        sleep(2);
  292. X        cribscore();
  293. X    }
  294. X}
  295. X
  296. Xhandscore(who)
  297. Xint who;
  298. X{
  299. X    int i;
  300. X    CARD dummy[5];
  301. X    for (i=0; i<4; i++) dummy[i]=hand[who][i];
  302. X    dummy[4]=cut;
  303. X    evalhand(dummy, 0, who);
  304. X}
  305. X
  306. Xcribscore()
  307. X{
  308. X    int i;
  309. X    CARD dummy[5];
  310. X    for (i=0; i<4; i++) dummy[i]=crib[i];
  311. X    dummy[4]=cut;
  312. X    evalhand(dummy, 1, dealer);
  313. X}
  314. X
  315. Xint
  316. Xevalhand(ehand, iscrib, whoscore)
  317. XCARD ehand[];
  318. Xint iscrib;
  319. Xint whoscore;    /* -1 means silent */
  320. X{
  321. X/*
  322. X *    If iscrib is on, don't allow four-flushes.
  323. X */
  324. X    int i, j, mask, bit, hmask, sum, hcount;
  325. X    char *runname;
  326. X    int runval;
  327. X    short rep[15];        /* Extra zeroes make it easier */
  328. X    WINDOW *Win;
  329. X    if (whoscore==1) Win=Hscore;
  330. X    else if (whoscore==0) Win=Pscore;
  331. X    if (iscrib && whoscore>=0) {
  332. X        wprintw(Win, "%s Crib:\n", whoscore? "Your": "My");
  333. X        wrefresh(Win);
  334. X        sleep(1);
  335. X    }
  336. X    hcount=0;
  337. X    for (mask=1; mask<32; mask++) {
  338. X        hmask=mask;
  339. X        sum=0;
  340. X        for (bit=0; bit<5; bit++) {
  341. X            if (1&hmask)
  342. X                sum+=rankvalue[RANK(ehand[bit])];
  343. X            hmask >>= 1;
  344. X        }
  345. X        if (sum==15) {
  346. X            hcount += 2;
  347. X            if (whoscore>=0) {
  348. X                wprintw(Win, "Fifteen-%d\n", hcount);
  349. X                wrefresh(Win);
  350. X                sleep(1);
  351. X            }
  352. X        }
  353. X/*
  354. X *    Need we add any cards?
  355. X */
  356. X        if (sum >= 15) mask |= mask-1;
  357. X    }
  358. X/*
  359. X *    Count the ranks.
  360. X */
  361. X    for (i=0; i<15; i++) rep[i]=0;
  362. X    for (i=0; i<5; i++) rep[RANK(ehand[i])]+=1;
  363. X/*
  364. X *    Look for isolated pairs, etc.
  365. X */
  366. X    for (i=1; i<14; i++) if (rep[i]>1) {
  367. X        if (!(rep[i-1] && (rep[i-2] || rep[i+1]) ||
  368. X        rep[i+1] && rep[i+2])) {
  369. X            hcount += pairvalue[rep[i]];
  370. X            if (whoscore>=0) {
  371. X                wprintw(Win, "and a %s is %d\n", 
  372. X                pairname[rep[i]], hcount);
  373. X                wrefresh(Win);
  374. X                sleep(1);
  375. X            }
  376. X        }
  377. X    }
  378. X/*
  379. X *    Look for runs, including multiples.
  380. X */
  381. X    for (i=1; i<12; i++) if (rep[i]) {
  382. X        if (!rep[i+2]) {
  383. X            i+=2;
  384. X            continue;
  385. X        }
  386. X        if (!rep[i+1]) {
  387. X            i+=1;
  388. X            continue;
  389. X        }
  390. X/*
  391. X *    We have a run!
  392. X */
  393. X        if (rep[i+3]) {
  394. X            if (rep[i+4]) {
  395. X                runname="Sequence of Five\n";
  396. X                runval=5;
  397. X            }
  398. X            else {
  399. X                runname="Sequence of Four\n";
  400. X                runval=4;
  401. X                for (j=i; j<i+4; j++) if (rep[j]>1) {
  402. X                    runname="Double Sequence\n of Four";
  403. X                    runval=10;
  404. X                    break;
  405. X                }
  406. X            }
  407. X        }
  408. X        else {
  409. X            for (sum=0, j=i; j<i+3; j++) {
  410. X                if (rep[j]==3) {
  411. X                    runname="Triple Sequence";
  412. X                    runval=15;
  413. X                    goto scorerun;
  414. X                }
  415. X                sum += rep[j]-1;
  416. X            }
  417. X            runname=drunname[sum];
  418. X            runval=drunval[sum];
  419. X        }
  420. Xscorerun:
  421. X        hcount += runval;
  422. X        if (whoscore>=0) {
  423. X            wprintw(Win, "and a %s is %d\n", runname, hcount);
  424. X            wrefresh(Win);
  425. X            sleep(1);
  426. X        }
  427. X        break;        /* You can't have two runs */
  428. X    }
  429. X/*
  430. X *    Check for flushes.
  431. X */
  432. X    for (i=1; i<4; i++) if (!SAMESUIT(ehand[i],ehand[0])) goto endflush;
  433. X    if (SAMESUIT(ehand[4], ehand[0])) {
  434. X        hcount += 5;
  435. X        if (whoscore>=0) {
  436. X            wprintw(Win, "and a Flush of Five is %d\n", hcount);
  437. X            wrefresh(Win);
  438. X            sleep(1);
  439. X        }
  440. X    }
  441. X    else if (!iscrib) {
  442. X        hcount += 4;
  443. X        if (whoscore>=0) {
  444. X            wprintw(Win, "and a Flush is %d\n", hcount);
  445. X            wrefresh(Win);
  446. X            sleep(1);
  447. X        }
  448. X    }
  449. Xendflush:
  450. X    for (i=0; i<4; i++)
  451. X    if (RANK(ehand[i])==KNAVE && SAMESUIT(ehand[i], ehand[4])) {
  452. X        hcount += 1;
  453. X        if (whoscore>=0) {
  454. X            wprintw(Win, "and One for His Nobs is %d\n",hcount);
  455. X            wrefresh(Win);
  456. X            sleep(1);
  457. X        }
  458. X        break;
  459. X    }
  460. X/*
  461. X *    Final reckoning, if wanted.
  462. X */
  463. X    if (whoscore>=0) {
  464. X        sleep(1);
  465. X        if (hcount) SCOREUP(whoscore, hcount);
  466. X    }
  467. X    return hcount;
  468. X}
  469. END_OF_gamescore.c
  470. if test 3455 -ne `wc -c <gamescore.c`; then
  471.     echo shar: \"gamescore.c\" unpacked with wrong size!
  472. fi
  473. # end of overwriting check
  474. fi
  475. if test -f globs.c -a "${1}" != "-c" ; then 
  476.   echo shar: Will not over-write existing file \"globs.c\"
  477. else
  478. echo shar: Extracting \"globs.c\" \(1014 characters\)
  479. sed "s/^X//" >globs.c <<'END_OF_globs.c'
  480. X/*
  481. X *    globs - global variables.
  482. X */
  483. X
  484. X#include "defs.h"
  485. X
  486. Xshort    count;
  487. XCARD    crib[6];
  488. XCARD    cut;
  489. Xint    dealer;
  490. Xint    (*dscfunc[2])();
  491. Xchar    gameover;
  492. XCARD    go[8];
  493. Xshort    gocount;
  494. XCARD    hand[2][6];
  495. Xchar    handover;
  496. Xshort    hflag = 0;
  497. Xshort    ncrib;
  498. Xshort    nleft[2];
  499. XCARD    pack[52];
  500. Xint    packmade = 0;
  501. Xshort    peg[2][2];
  502. Xchar    played[2][4];
  503. XPLAYER    playertype[2];
  504. Xchar    quitflag;
  505. Xshort    score[2];
  506. Xshort    whosego;
  507. Xchar    whoseturn;
  508. X
  509. Xchar    *drunname[3] = {"Sequence","Double Sequence",
  510. X        "Quadruple Sequence"};
  511. Xshort    drunval[3] = {3, 8, 16};
  512. Xchar    *pairname[5] = {"0","0","Pair","Pair Royal","Double Pair Royal"};
  513. Xshort    pairvalue[5] = {0,0,2,6,12};
  514. Xchar    *rankname[14] = {"0", "Ace","Deuce","Trey","Four",
  515. X            "Five","Six","Seven","Eight","Nine","Ten",
  516. X            "Knave","Queen","King"};
  517. Xchar    *rankrdr[14] = {"0", "A",
  518. X        "2","3","4","5","6","7","8","9","10","J","Q","K"};
  519. Xshort    rankvalue[14] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10};
  520. Xchar    *suitname[5] = {"Clubs", "Diamonds", "Hearts", "Spades", "Cabbages"};
  521. Xchar    *suitrdr[5] = {"c","d","h","s","x"};
  522. END_OF_globs.c
  523. if test 1014 -ne `wc -c <globs.c`; then
  524.     echo shar: \"globs.c\" unpacked with wrong size!
  525. fi
  526. # end of overwriting check
  527. fi
  528. if test -f globs.h -a "${1}" != "-c" ; then 
  529.   echo shar: Will not over-write existing file \"globs.h\"
  530. else
  531. echo shar: Extracting \"globs.h\" \(782 characters\)
  532. sed "s/^X//" >globs.h <<'END_OF_globs.h'
  533. X/*
  534. X *    globs.h - global variables.
  535. X */
  536. X
  537. Xextern    short    count;
  538. Xextern    CARD    crib[6];
  539. Xextern    CARD    cut;
  540. Xextern    int    dealer;
  541. Xextern    char    *drunname[];
  542. Xextern    short    drunval[];
  543. Xextern    int    (*dscfunc[])();
  544. Xextern    char    gameover;
  545. Xextern    CARD    go[8];
  546. Xextern    short    gocount;
  547. Xextern    CARD    hand[2][6];
  548. Xextern    char    handover;
  549. Xextern    short    hflag;
  550. Xextern    short    ncrib;
  551. Xextern    short    nleft[2];
  552. Xextern    CARD    pack[52];
  553. Xextern    int    packmade;
  554. Xextern    char    *pairname[];
  555. Xextern    short    pairvalue[];
  556. Xextern    short    peg[2][2];
  557. Xextern    char    played[2][4];
  558. Xextern    PLAYER    playertype[2];
  559. Xextern    char    quitflag;
  560. Xextern    char    *rankname[14];
  561. Xextern    char    *rankrdr[14];
  562. Xextern    short    rankvalue[14];
  563. Xextern    short    score[2];
  564. Xextern    char    *suitname[5];
  565. Xextern    char    *suitrdr[5];
  566. Xextern    char    version[];
  567. Xextern    short    whosego;
  568. Xextern    char    whoseturn;
  569. END_OF_globs.h
  570. if test 782 -ne `wc -c <globs.h`; then
  571.     echo shar: \"globs.h\" unpacked with wrong size!
  572. fi
  573. # end of overwriting check
  574. fi
  575. if test -f human.c -a "${1}" != "-c" ; then 
  576.   echo shar: Will not over-write existing file \"human.c\"
  577. else
  578. echo shar: Extracting \"human.c\" \(3095 characters\)
  579. sed "s/^X//" >human.c <<'END_OF_human.c'
  580. X#include "defs.h"
  581. X#include "globs.h"
  582. X#include "window.h"
  583. X
  584. X#ifdef    BSD
  585. X#include <ctype.h>
  586. X#endif
  587. X
  588. Xstatic    char selected[6];
  589. Xstatic    int nselected;
  590. X
  591. Xhumandiscard(hand, mydeal)
  592. XCARD hand[];
  593. Xint mydeal;
  594. X{
  595. X    int j, j1, j2;
  596. X    char k;
  597. X    for (j=0; j<6; j++) mvwaddch(Select, 0, 5*j+2, 'a'+j);
  598. X    wrefresh(Select);
  599. X    mvwprintw(
  600. X    Prompt, 0, 0, mydeal? "It is your crib.\n": "It is my crib.\n");
  601. X#ifdef GDISC
  602. X    mvwprintw(Prompt, 1, 0, "Select 2 cards.  Type \"g\" to discard.\n");
  603. X#else
  604. X    mvwprintw(Prompt, 1, 0, "Select 2 cards.  Type RETURN to discard.\n");
  605. X#endif
  606. X    if (hflag) {
  607. X        mvwprintw(Hscore, 0, 0, "Type \"h\" for hint\n");
  608. X        wrefresh(Hscore);
  609. X    }
  610. X    for (j=0; j<6; j++) selected[j]=0;
  611. X    nselected = 0;
  612. X    for (;;) {
  613. X        mvwaddch(Prompt, 1, 41, '\n');
  614. X        wmove(Prompt, 1, 41);
  615. X        wrefresh(Prompt);
  616. X        k = wgetch(Prompt);
  617. X        k = tolower(k);
  618. X#ifdef GDISC
  619. X        if ('g'==k) {
  620. X#else
  621. X        if ('\n'==k || '\r'==k) {
  622. X#endif
  623. X            if (nselected == 2) break;
  624. X            beep();
  625. X            continue;
  626. X        }
  627. X        if (hflag && k == 'h') {
  628. X            hint(hand, mydeal);
  629. X            continue;
  630. X        }
  631. X        if (k > 'f' || k < 'a') {
  632. X            beep();
  633. X            continue;
  634. X        }
  635. X        nselected -= selected[k-'a'];
  636. X        nselected += (selected[k-'a'] ^= 1);
  637. X        mvwaddch(Humanhand, 2, 5*(k-'a')+3,
  638. X            selected[k-'a']? '*': ' ');
  639. X        wrefresh(Humanhand);
  640. X    }
  641. X    if (hflag) {
  642. X        werase(Hscore);
  643. X        wrefresh(Hscore);
  644. X    }
  645. X    werase(Select);
  646. X    werase(Prompt);
  647. X    wrefresh(Select);
  648. X    wrefresh(Prompt);
  649. X    for (j=0; j<6; j++) if (selected[j]) {
  650. X        j1 = j2;    /* and you know Lint won't like this! */
  651. X        j2 = j;
  652. X    }
  653. X    makediscard(hand, j1, j2);
  654. X}
  655. X
  656. Xhint(ihand, mydeal)
  657. X{
  658. X    int a, b, k;
  659. X    bestdis(ihand, mydeal, &a, &b);
  660. X    for (k=0; k<6; k++) {
  661. X        selected[k] = k==a || k==b;
  662. X        mvwaddch(Humanhand, 2, 5*k+3, selected[k]? '*': ' ');
  663. X    }
  664. X    nselected = 2;
  665. X    werase(Hscore);
  666. X    wrefresh(Humanhand);
  667. X    wrefresh(Hscore);
  668. X}
  669. X
  670. Xhumanplay()
  671. X{
  672. X    char k;
  673. X    int sco;
  674. X    if (whosego == whoseturn) {
  675. X/*
  676. X *    It is my go.  Can I play?
  677. X */
  678. X        if (goodgo(whoseturn)) {
  679. X            SCOREUP(whoseturn, 1);
  680. X            resetgo();
  681. X            handover = !nleft[0] && !nleft[1];
  682. X            return;
  683. X        }
  684. X        else mvwprintw(Prompt, 1, 0, "Select a card.\n");
  685. X    }
  686. X    else if (!nleft[whoseturn]) {
  687. X        handover = !nleft[0] && !nleft[1];
  688. X        if (handover) SCOREUP(whoseturn, 1);
  689. X        return;
  690. X    }
  691. X    else if (whosego == !whoseturn) return;
  692. X    else mvwprintw(Prompt, 1, 0, "Select a card, or type \"g\" for go.");
  693. X    for (;;) {
  694. X        mvwaddch(Prompt, 1, 41, '\n');
  695. X        wrefresh(Prompt);
  696. X        k = wgetch(Prompt);
  697. X        k = tolower(k);
  698. X        if (k == 'g') {
  699. X            if (goodgo(whoseturn)) {
  700. X                whosego = !whoseturn;
  701. X                return;
  702. X            }
  703. X            else beep();
  704. X        }
  705. X        else if (k < 'a' || k > 'd') beep();
  706. X        else if (goodplay(whoseturn, k-'a')) break;
  707. X        else beep();
  708. X    }
  709. X    werase(Prompt);
  710. X    played[whoseturn][k-'a'] = 1;
  711. X    count += rankvalue[RANK(hand[whoseturn][k-'a'])];
  712. X    go[gocount++] = hand[whoseturn][k-'a'];
  713. X    nleft[whoseturn] -= 1;
  714. X    sco = playscore();
  715. X    showhplay(k-'a', sco);
  716. X    if (sco) SCOREUP(whoseturn, sco);
  717. X    handover = !nleft[0] && !nleft[1];
  718. X    if (count==31) resetgo();
  719. X    else if (handover) {
  720. X        mvwprintw(Prompt, 0, 0, "That's a Go\n");
  721. X        SCOREUP(whoseturn, 1);
  722. X    }
  723. X    sleep(1);
  724. X}
  725. X
  726. X/*
  727. X *    This is pre-defined in Vr2 curses, but I'll just define it anyway.
  728. X */
  729. Xbeep()
  730. X{
  731. X    putchar('\007');
  732. X}
  733. END_OF_human.c
  734. if test 3095 -ne `wc -c <human.c`; then
  735.     echo shar: \"human.c\" unpacked with wrong size!
  736. fi
  737. # end of overwriting check
  738. fi
  739. if test -f logaux.c -a "${1}" != "-c" ; then 
  740.   echo shar: Will not over-write existing file \"logaux.c\"
  741. else
  742. echo shar: Extracting \"logaux.c\" \(173 characters\)
  743. sed "s/^X//" >logaux.c <<'END_OF_logaux.c'
  744. X#include "defs.h"
  745. X
  746. Xint
  747. Xcindex(a, b)
  748. XCARD a, b;
  749. X{
  750. X    register t, u;
  751. X    t = RANK(a);
  752. X    u = RANK(b);
  753. X    if (t < u) {
  754. X        t = RANK(b);
  755. X        u = RANK(a);
  756. X    }
  757. X    return u - 1 + (t * (t-1))/2;
  758. X}
  759. END_OF_logaux.c
  760. if test 173 -ne `wc -c <logaux.c`; then
  761.     echo shar: \"logaux.c\" unpacked with wrong size!
  762. fi
  763. # end of overwriting check
  764. fi
  765. if test -f logglobs.c -a "${1}" != "-c" ; then 
  766.   echo shar: Will not over-write existing file \"logglobs.c\"
  767. else
  768. echo shar: Extracting \"logglobs.c\" \(1136 characters\)
  769. sed "s/^X//" >logglobs.c <<'END_OF_logglobs.c'
  770. Xfloat    distable[2][91] = {
  771. X6.290,5.028,6.490,5.092,7.256,6.744,5.776,5.297,5.917,6.699,6.083,6.181,
  772. X6.734,7.222,9.463,4.993,5.068,4.909,5.277,7.528,7.152,5.177,5.145,5.070,
  773. X4.969,7.061,6.503,7.451,4.954,4.970,4.963,4.922,6.283,5.951,8.103,6.808,
  774. X4.725,4.810,4.826,4.745,6.170,6.434,5.402,5.959,6.536,4.504,4.610,4.586,
  775. X4.485,7.476,4.332,4.465,5.043,5.568,6.114,4.786,4.893,4.869,4.767,7.758,
  776. X4.615,4.826,4.678,5.140,5.478,6.666,4.360,4.467,4.443,4.341,7.332,4.189,
  777. X4.400,4.310,4.089,4.564,5.359,5.824,4.211,4.318,4.294,4.192,7.184,4.040,
  778. X4.251,4.162,4.019,3.763,4.650,4.290,5.526,5.580,4.339,5.966,4.585,7.183,
  779. X6.102,5.596,4.545,4.892,5.808,5.562,5.583,6.039,6.501,8.909,3.868,3.876,
  780. X3.839,3.818,6.538,5.846,3.784,3.856,3.678,3.797,5.986,4.795,5.945,3.730,
  781. X3.644,3.879,3.830,5.490,4.448,6.535,5.380,3.453,3.780,3.828,3.780,5.477,
  782. X5.234,3.940,4.531,5.259,3.462,3.602,3.650,3.601,6.725,3.089,3.069,3.742,
  783. X4.130,4.878,3.746,3.886,3.934,3.885,7.009,3.372,3.406,3.348,3.933,4.530,
  784. X5.435,3.534,3.673,3.722,3.672,6.797,3.160,3.194,3.194,3.086,3.336,4.858,
  785. X5.005,3.531,3.671,3.719,3.670,6.794,3.158,3.192,3.191,3.126,2.889,4.031,
  786. X3.469,5.003
  787. X};
  788. END_OF_logglobs.c
  789. if test 1136 -ne `wc -c <logglobs.c`; then
  790.     echo shar: \"logglobs.c\" unpacked with wrong size!
  791. fi
  792. # end of overwriting check
  793. fi
  794. if test -f logglobs.h -a "${1}" != "-c" ; then 
  795.   echo shar: Will not over-write existing file \"logglobs.h\"
  796. else
  797. echo shar: Extracting \"logglobs.h\" \(30 characters\)
  798. sed "s/^X//" >logglobs.h <<'END_OF_logglobs.h'
  799. Xextern    float    distable[2][91];
  800. END_OF_logglobs.h
  801. if test 30 -ne `wc -c <logglobs.h`; then
  802.     echo shar: \"logglobs.h\" unpacked with wrong size!
  803. fi
  804. # end of overwriting check
  805. fi
  806. if test -f nobs.6 -a "${1}" != "-c" ; then 
  807.   echo shar: Will not over-write existing file \"nobs.6\"
  808. else
  809. echo shar: Extracting \"nobs.6\" \(742 characters\)
  810. sed "s/^X//" >nobs.6 <<'END_OF_nobs.6'
  811. X.de QU
  812. X.ie t ``\\$1''\\$2
  813. X.el "\\$1"\\$2
  814. X..
  815. X.TH NOBS 6 "23 March 1988" "" "Local UNIX Programmer's Manual"
  816. X.SH NAME
  817. Xnobs \- cribbage game
  818. X.SH SYNOPSIS
  819. X.B nobs
  820. X[
  821. X.if '\*(nh'' \{\
  822. X.B \-h
  823. X] [\}
  824. X.B \-v
  825. X]
  826. X.SH DESCRIPTION
  827. XWith no arguments,
  828. X.I nobs
  829. Xplays screen-oriented games of cribbage with you.
  830. XYou select cards by typing a letter from
  831. X.QU a
  832. Xto
  833. X.QU f .
  834. XThe program keeps score.
  835. XGame is 121 points.
  836. X.PP
  837. X.if '\*(nh'' \{\
  838. XIf you specify
  839. X.BR \-h ,
  840. X.I nobs
  841. Xwill offer you hints on discarding.\}
  842. XIf you specify
  843. X.BR \-v ,
  844. X.I nobs
  845. Xprints the version number and exits.
  846. X.SH WARNING
  847. XThis program has been around a long time, having started out 
  848. Xin FORTRAN on a CDC 6400.
  849. XIt is a dangerous opponent.
  850. X.SH AUTHOR
  851. XG. L. Sicherman  (ihnp4\^!\^odyssey\^!\^gls)
  852. END_OF_nobs.6
  853. if test 742 -ne `wc -c <nobs.6`; then
  854.     echo shar: \"nobs.6\" unpacked with wrong size!
  855. fi
  856. # end of overwriting check
  857. fi
  858. if test -f nobs.c -a "${1}" != "-c" ; then 
  859.   echo shar: Will not over-write existing file \"nobs.c\"
  860. else
  861. echo shar: Extracting \"nobs.c\" \(801 characters\)
  862. sed "s/^X//" >nobs.c <<'END_OF_nobs.c'
  863. X/*
  864. X *    nobs - play cribbage.
  865. X */
  866. X
  867. X#include <stdio.h>
  868. X#include "defs.h"
  869. X#include "globs.h"
  870. X
  871. Xextern    int    programdiscard();
  872. Xextern    int    humandiscard();
  873. X
  874. Xusage()
  875. X{
  876. X#ifdef    NOHINT
  877. X    fprintf(stderr,"usage: nobs [-v]\n");
  878. X#else
  879. X    fprintf(stderr,"usage: nobs [-h] [-v]\n");
  880. X#endif
  881. X    exit(-1);
  882. X}
  883. X
  884. Xmain(argc,argv)
  885. Xint argc;
  886. Xchar **argv;
  887. X{
  888. X    while (--argc) {
  889. X        if ('-'==**++argv) switch(*++*argv) {
  890. X        case 'v':
  891. X            printf("Nobs Version %s\n", version);
  892. X            exit(0);
  893. X#ifndef    NOHINT
  894. X        case 'h':
  895. X            hflag = 1;
  896. X            break;
  897. X#endif
  898. X        default:
  899. X            usage();
  900. X        }
  901. X        else break;
  902. X    }
  903. X    if (argc) usage();
  904. X    initrand();
  905. X    initwins();
  906. X    dealer = randint(2);
  907. X    playertype[0] = PROGRAM;
  908. X    playertype[1] = HUMAN;
  909. X    dscfunc[PROGRAM] = programdiscard;
  910. X    dscfunc[HUMAN] = humandiscard;
  911. X    for (quitflag=0; !quitflag; ) playgame();
  912. X    termwins();
  913. X    exit(0);
  914. X}
  915. END_OF_nobs.c
  916. if test 801 -ne `wc -c <nobs.c`; then
  917.     echo shar: \"nobs.c\" unpacked with wrong size!
  918. fi
  919. # end of overwriting check
  920. fi
  921. if test -f pegs.c -a "${1}" != "-c" ; then 
  922.   echo shar: Will not over-write existing file \"pegs.c\"
  923. else
  924. echo shar: Extracting \"pegs.c\" \(1181 characters\)
  925. sed "s/^X//" >pegs.c <<'END_OF_pegs.c'
  926. X#include "defs.h"
  927. X#include "globs.h"
  928. X#include "window.h"
  929. X
  930. Xint
  931. Xpegcol(n)
  932. Xint n;
  933. X{
  934. X    if (n==0) return 0;
  935. X    else if (n<31) return n+(n+4)/5;
  936. X    else return 74-n-(n+4)/5;
  937. X}
  938. X
  939. Xresetpegs()
  940. X{
  941. X    int i, j;
  942. X    for (i=0; i<2; i++) for (j=0; j<2; j++) {
  943. X        if (peg[i][j] != 0) {
  944. X            mvwaddch(Board, 2*i, pegcol(peg[i][j]), ':');
  945. X            peg[i][j] = 0;
  946. X        }
  947. X    }
  948. X    for (i=0; i<2; i++) mvwaddch(Board, 2*i, 0, '|');
  949. X    wrefresh(Board);
  950. X}
  951. X
  952. Xsetpegs(who)
  953. XPLAYER    who;
  954. X{
  955. X/*
  956. X *    The first peg in the array is the forward peg.
  957. X */
  958. X
  959. X/*    Pick up the hindward peg.  */
  960. X    if (peg[who][0] == 0) mvwaddch(Board, 2*who, 0, who? '!': ';');
  961. X    else if (peg[who][1] + peg[who][0] == 61)
  962. X        mvwaddch(Board, 2*who, pegcol(peg[who][1]),
  963. X        (peg[who][1]>30)==who? ';': '!');
  964. X    else mvwaddch(Board, 2*who, pegcol(peg[who][1]), ':');
  965. X/*
  966. X *    Put it down again.
  967. X */
  968. X    peg[who][1] = peg[who][0];
  969. X    if (score[who] > 120) peg[who][0] = 0;
  970. X    else peg[who][0] = 1+(score[who]-1)%60;
  971. X    if (peg[who][0]==0) mvwaddch(Board, 2*who, 0, who? '!': ';');
  972. X    else if (peg[who][0] + peg[who][1] == 61)
  973. X        mvwaddch(Board, 2*who, pegcol(peg[who][0]), '|');
  974. X    else mvwaddch(Board, 2*who, pegcol(peg[who][0]),
  975. X        (peg[who][0]>30)==who? '!': ';');
  976. X    wrefresh(Board);
  977. X    sleep(1);
  978. X}
  979. END_OF_pegs.c
  980. if test 1181 -ne `wc -c <pegs.c`; then
  981.     echo shar: \"pegs.c\" unpacked with wrong size!
  982. fi
  983. # end of overwriting check
  984. fi
  985. if test -f play.c -a "${1}" != "-c" ; then 
  986.   echo shar: Will not over-write existing file \"play.c\"
  987. else
  988. echo shar: Extracting \"play.c\" \(1823 characters\)
  989. sed "s/^X//" >play.c <<'END_OF_play.c'
  990. X#include "defs.h"
  991. X#include "globs.h"
  992. X#include "window.h"
  993. X
  994. Xstatic    taketurn();
  995. X
  996. Xplaygame()
  997. X{
  998. X    char k;
  999. X    score[0]=score[1]=0;
  1000. X    resetpegs();
  1001. X    for (gameover=0; !gameover; ) playhand();
  1002. X    mvwprintw(Prompt, 0, 0, score[0]>120? "I win.\n": "You win.\n");
  1003. X    wrefresh(Prompt);
  1004. X    sleep(2);
  1005. X    mvwprintw(Prompt, 1, 0, "Another game?\n");
  1006. X    wmove(Prompt, 1, 41);
  1007. X    wrefresh(Prompt);
  1008. X    k = wgetch(Prompt);
  1009. X    if (k != 'y' && k != 'Y') quitflag = 1;
  1010. X}
  1011. X
  1012. Xplayhand()
  1013. X{
  1014. X    int i, j;
  1015. X    dealer = !dealer;
  1016. X    deal();
  1017. X    werase(Pscore);
  1018. X    werase(Hscore);
  1019. X    showhand();
  1020. X    ncrib=0;
  1021. X    for (i=0; i<2; i++) {
  1022. X        (*dscfunc[playertype[i]])(hand[i], i==dealer);
  1023. X    }
  1024. X    showfour();
  1025. X    showcut();
  1026. X    if (RANK(cut)==KNAVE) {
  1027. X        mvwprintw(Prompt, 1, 0, "Two for His Heels\n");
  1028. X        wrefresh(Prompt);
  1029. X        sleep(2);
  1030. X        SCOREUP(dealer, 2);
  1031. X        sleep(1);
  1032. X    }
  1033. X    whoseturn = dealer;    /* to be reversed */
  1034. X    handover = 0;
  1035. X    nleft[0]=nleft[1]=4;
  1036. X    resetgo();
  1037. X    for (i=0; i<2; i++) for (j=0; j<4; j++) played[i][j]=0;
  1038. X    while (!gameover && !handover) taketurn();
  1039. X    if (gameover) return;
  1040. X    gamescore();
  1041. X}
  1042. X
  1043. Xstatic
  1044. Xtaketurn()
  1045. X{
  1046. X    whoseturn = !whoseturn;
  1047. X    switch (playertype[whoseturn]) {
  1048. X    case HUMAN:
  1049. X        humanplay();
  1050. X        break;
  1051. X    case PROGRAM:
  1052. X        programplay();
  1053. X        break;
  1054. X    }
  1055. X}
  1056. X
  1057. Xint
  1058. Xgoodgo(who)
  1059. Xint who;
  1060. X{
  1061. X    int i;
  1062. X    for (i=0; i<4; i++) if (goodplay(who, i)) return 0;
  1063. X    return 1;
  1064. X}
  1065. X
  1066. Xint
  1067. Xgoodplay(who, which)
  1068. Xint who, which;
  1069. X{
  1070. X    return !played[who][which] &&
  1071. X    rankvalue[RANK(hand[who][which])] + count <= 31;
  1072. X}
  1073. X
  1074. Xresetgo() {
  1075. X    count=gocount=0;
  1076. X    whosego = -1;
  1077. X    mvwprintw(Prompt, 0, 0, "0.\n");
  1078. X    wrefresh(Prompt);
  1079. X}
  1080. X
  1081. X/*
  1082. X *    Returns nonzero if wins.
  1083. X */
  1084. Xscoreup(who, n)
  1085. Xint who, n;
  1086. X{
  1087. X    score[who] += n;
  1088. X    setpegs(who);
  1089. X    return (score[who] > 120);
  1090. X}
  1091. X
  1092. X/*
  1093. X *    assumes a<b.
  1094. X */
  1095. X
  1096. Xmakediscard(hand, a, b)
  1097. Xint a, b;
  1098. XCARD hand[];
  1099. X{
  1100. X    crib[ncrib++] = hand[a];
  1101. X    crib[ncrib++] = hand[b];
  1102. X    hand[b]=hand[5];
  1103. X    hand[a]=hand[4];    /* In this order only. */
  1104. X}
  1105. END_OF_play.c
  1106. if test 1823 -ne `wc -c <play.c`; then
  1107.     echo shar: \"play.c\" unpacked with wrong size!
  1108. fi
  1109. # end of overwriting check
  1110. fi
  1111. if test -f playscore.c -a "${1}" != "-c" ; then 
  1112.   echo shar: Will not over-write existing file \"playscore.c\"
  1113. else
  1114. echo shar: Extracting \"playscore.c\" \(968 characters\)
  1115. sed "s/^X//" >playscore.c <<'END_OF_playscore.c'
  1116. X#include "defs.h"
  1117. X#include "globs.h"
  1118. X
  1119. Xint
  1120. Xplayscore()
  1121. X{
  1122. X    int hold, low;
  1123. X    hold = 0;
  1124. X    if (count == 15 || count == 31) hold=2;
  1125. X    if (gocount > 1 && RANK(go[gocount-2])==RANK(go[gocount-1])) {
  1126. X        hold += 2;
  1127. X        if (gocount > 2 && RANK(go[gocount-3])==RANK(go[gocount-2])) {
  1128. X            hold += 4;
  1129. X            if (gocount > 3 && RANK(go[gocount-4])==
  1130. X            RANK(go[gocount-3])) hold += 6;
  1131. X        }
  1132. X        return hold;    /* No need to check for runs */
  1133. X    }
  1134. X    if (gocount < 3) return hold;
  1135. X    for (low=0; low<gocount-2; low++)
  1136. X    if (isplrun(low, gocount-low)) return hold+gocount-low;
  1137. X    return hold;
  1138. X}
  1139. X
  1140. Xint
  1141. Xisplrun(start, num)
  1142. Xint start, num;
  1143. X{
  1144. X    int highest, lowest, i;
  1145. X    register mask;
  1146. X    lowest = KING;
  1147. X    highest = ACE;
  1148. X    for (i=start; i<start+num; i++) {
  1149. X        if (RANK(go[i])>highest) highest=RANK(go[i]);
  1150. X        if (RANK(go[i])<lowest) lowest=RANK(go[i]);
  1151. X    }
  1152. X    if (highest != lowest+num-1) return 0;
  1153. X/*
  1154. X *    Use a mask.
  1155. X */
  1156. X    mask = (1<<num)-1;
  1157. X    for (i=start; i<start+num; i++) mask &= ~(1<<(RANK(go[i])-lowest));
  1158. X    return !mask;
  1159. X}
  1160. END_OF_playscore.c
  1161. if test 968 -ne `wc -c <playscore.c`; then
  1162.     echo shar: \"playscore.c\" unpacked with wrong size!
  1163. fi
  1164. # end of overwriting check
  1165. fi
  1166. if test -f progaux.c -a "${1}" != "-c" ; then 
  1167.   echo shar: Will not over-write existing file \"progaux.c\"
  1168. else
  1169. echo shar: Extracting \"progaux.c\" \(1873 characters\)
  1170. sed "s/^X//" >progaux.c <<'END_OF_progaux.c'
  1171. X/*
  1172. X *    nobs - auxiliary program strategy functions.
  1173. X *    G. L. Sicherman.
  1174. X */
  1175. X
  1176. X#include "defs.h"
  1177. X#include "globs.h"
  1178. X#include "logglobs.h"
  1179. X
  1180. Xfloat evaldiscard();
  1181. X
  1182. Xbestdis(hand, mydeal, aw, bw)
  1183. XCARD hand[];
  1184. Xint mydeal;
  1185. Xint *aw, *bw;
  1186. X{
  1187. X    float best, new;
  1188. X    int a, b;
  1189. X    best = -999.0;
  1190. X    for (a=0; a<5; a++) for (b=a+1; b<6; b++) {
  1191. X        new = evaldiscard(hand, mydeal, a, b);
  1192. X        if (new>best) {
  1193. X            best=new;
  1194. X            *aw=a;
  1195. X            *bw=b;
  1196. X        }
  1197. X    }
  1198. X}
  1199. X
  1200. Xfloat
  1201. Xevaldiscard(hand, mydeal, j1, j2)
  1202. XCARD    hand[6];
  1203. Xint    mydeal, j1, j2;
  1204. X{
  1205. X    float retval, disval;
  1206. X    CARD holdhand[5], *hp;
  1207. X    int k, m, v;
  1208. X    int cutrank;
  1209. X/*
  1210. X *    Evaluate the remaining hand.
  1211. X */
  1212. X    retval = 0.0;
  1213. X    hp=holdhand;
  1214. X    for (k=0; k<6; k++) if (k!=j1 && k!=j2) *hp++ = hand[k];
  1215. X    for (cutrank=ACE; cutrank<=KING; cutrank++) {
  1216. X        holdhand[4] = MAKECARD(cutrank, CABBAGE);
  1217. X        v = evalhand(holdhand, 1, -1);
  1218. X        retval += 4 * v;
  1219. X        for (m=0; m<6; m++)
  1220. X        if (SAMERANK(hand[m], holdhand[4])) retval -= v;
  1221. X    }
  1222. X    retval /= 46;
  1223. X    disval = distable[mydeal][cindex(hand[j1],hand[j2])];
  1224. X    if (!mydeal) disval= -disval;
  1225. X    retval += disval;
  1226. X    return retval;
  1227. X}
  1228. X
  1229. X/*
  1230. X *    This isn't supposed to be a world-class strategy.
  1231. X */
  1232. Xint
  1233. Xevalplay(c)
  1234. XCARD c;
  1235. X{
  1236. X    int v;
  1237. X    v = rankvalue[RANK(c)];
  1238. X/*
  1239. X *    Are we setting human up for a 15?
  1240. X */
  1241. X    if (count+v == 5) return -11;
  1242. X/*
  1243. X *    Are we setting human up for a 31?
  1244. X */
  1245. X    if (count+v == 21) return -9;
  1246. X    if (count+v == 15 || count+v == 31) return 20;
  1247. X    if (gocount && RANK(go[gocount-1])==RANK(c)) {
  1248. X        if (gocount>1 && RANK(go[gocount-2])==RANK(c)) return 30;
  1249. X        if (gocount>3 || randint(5)) return 15;
  1250. X    }
  1251. X    if (gocount > 1 &&
  1252. X    isrun(RANK(go[gocount-1]),RANK(go[gocount-2]), RANK(c))) return 25;
  1253. X/*
  1254. X *    Are we setting human up for a run?
  1255. X */
  1256. X    if (gocount && 2==abs(RANK(c)-RANK(go[gocount-1]))) return -10;
  1257. X    if (count+v <= 4) return 10+count+v;
  1258. X    if (count>20) return v;
  1259. X    return 0;
  1260. X}
  1261. X
  1262. Xint
  1263. Xisrun(a,b,c)
  1264. Xint a,b,c;
  1265. X{
  1266. X    return 4==abs(a-b)+abs(a-c)+abs(b-c);
  1267. X}
  1268. END_OF_progaux.c
  1269. if test 1873 -ne `wc -c <progaux.c`; then
  1270.     echo shar: \"progaux.c\" unpacked with wrong size!
  1271. fi
  1272. # end of overwriting check
  1273. fi
  1274. if test -f program.c -a "${1}" != "-c" ; then 
  1275.   echo shar: Will not over-write existing file \"program.c\"
  1276. else
  1277. echo shar: Extracting \"program.c\" \(2213 characters\)
  1278. sed "s/^X//" >program.c <<'END_OF_program.c'
  1279. X/*
  1280. X *    The program's strategy.
  1281. X */
  1282. X
  1283. X#include "defs.h"
  1284. X#include "globs.h"
  1285. X#include "logglobs.h"
  1286. X#include "window.h"
  1287. X
  1288. Xfloat    evaldiscard();
  1289. X
  1290. Xprogramdiscard(ehand, mydeal)
  1291. XCARD ehand[];
  1292. Xint mydeal;
  1293. X{
  1294. X    int aw, bw;
  1295. X    bestdis(ehand, mydeal, &aw, &bw);
  1296. X    makediscard(ehand, aw, bw);
  1297. X    mvwaddch(Programhand, 0, 5*4, '\n');
  1298. X    mvwprintw(Crib, 0, 0, "XXX  XXX\n");
  1299. X    wrefresh(Programhand);
  1300. X    wrefresh(Crib);
  1301. X}
  1302. X
  1303. Xprogramplay()
  1304. X{
  1305. X    int t, u, v;
  1306. X    int bestplay, bestval;
  1307. X/*
  1308. X *    Case I:  It's the human's go.  Sit tight.
  1309. X */
  1310. X    if (whosego == !whoseturn) return;
  1311. X/*
  1312. X *    Case II:  It's my go, and I can't play.  Just score the
  1313. X *    go and reset.
  1314. X */
  1315. X    if (whosego==whoseturn && goodgo(whoseturn)) {
  1316. X/*
  1317. X *    If I have cards and human does not, explain to human.
  1318. X */
  1319. X        if (nleft[whoseturn] && !nleft[!whoseturn]) {
  1320. X            mvwprintw(Prompt, 1, 0, "That's a Go\n");
  1321. X            wrefresh(Prompt);
  1322. X            sleep(1);
  1323. X        }
  1324. X        SCOREUP(whoseturn, 1);
  1325. X        handover = !nleft[0] && !nleft[1];
  1326. X        if (!handover) resetgo();
  1327. X        return;
  1328. X    }
  1329. X/*
  1330. X *    Case III: It's nobody's go yet, and I can't play.
  1331. X *    Human still has cards, or we shouldn't be here.
  1332. X *    Say "go".
  1333. X */
  1334. X    if (goodgo(whoseturn)) {
  1335. X        whosego = !whoseturn;
  1336. X/*
  1337. X *    If I have no cards, there's no need to say "go."
  1338. X */
  1339. X        if (nleft[whoseturn]) {
  1340. X            mvwprintw(Prompt, 0, 11, "Go.\n");
  1341. X            wrefresh(Prompt);
  1342. X            sleep(1);
  1343. X        }
  1344. X        return;
  1345. X    }
  1346. X/*
  1347. X *    I can play.  Pick an appropriate play.
  1348. X */
  1349. X    bestval = -999;
  1350. X    for (t=0; t<4; t++) if (goodplay(whoseturn, t)) {
  1351. X        if ((v=evalplay(hand[whoseturn][t])) > bestval) {
  1352. X            bestval=v;
  1353. X            bestplay=t;
  1354. X        }
  1355. X    }
  1356. X    makeprogplay(bestplay);
  1357. X}
  1358. X
  1359. Xmakeprogplay(t)
  1360. Xint t;
  1361. X{
  1362. X    int sco;
  1363. X    nleft[whoseturn] -= 1;
  1364. X    played[whoseturn][t]=1;
  1365. X    count += rankvalue[RANK(hand[whoseturn][t])];
  1366. X    go[gocount++] = hand[whoseturn][t];
  1367. X    sco = playscore();
  1368. X    showpplay(whoseturn, t, sco);
  1369. X    if (sco) SCOREUP(whoseturn, sco);
  1370. X/*
  1371. X *    Say Go to myself?
  1372. X */
  1373. X    if (!nleft[whoseturn]) {    /* That was my last card. */
  1374. X        handover = !nleft[!whoseturn];
  1375. X        if (handover && count != 31) SCOREUP(whoseturn, 1);
  1376. X        if (!handover && (whosego==whoseturn || count==31)) resetgo();
  1377. X        return;
  1378. X    }
  1379. X    if (!nleft[!whoseturn]) whosego=whoseturn;    /* Human out of cards */
  1380. X    if (whosego != whoseturn) {
  1381. X        if (count==31) resetgo();
  1382. X        return;    /* Give human a chance */
  1383. X    }
  1384. X}
  1385. END_OF_program.c
  1386. if test 2213 -ne `wc -c <program.c`; then
  1387.     echo shar: \"program.c\" unpacked with wrong size!
  1388. fi
  1389. # end of overwriting check
  1390. fi
  1391. if test -f show.c -a "${1}" != "-c" ; then 
  1392.   echo shar: Will not over-write existing file \"show.c\"
  1393. else
  1394. echo shar: Extracting \"show.c\" \(2076 characters\)
  1395. sed "s/^X//" >show.c <<'END_OF_show.c'
  1396. X#include "defs.h"
  1397. X#include "globs.h"
  1398. X#include "window.h"
  1399. X
  1400. Xchar *
  1401. Xcardname(c)
  1402. XCARD c;
  1403. X{
  1404. X    static char hold[4];
  1405. X    sprintf(hold, "%2s%s", rankrdr[RANK(c)], suitrdr[SUIT(c)]);
  1406. X    return hold;
  1407. X}
  1408. X
  1409. Xshowhand()
  1410. X/*
  1411. X *    If a player is human, it's always player 1.
  1412. X */
  1413. X{
  1414. X    int i;
  1415. X    for (i=0; i<6; i++) mvwprintw(Programhand, 0, 5*i, "XXX");
  1416. X    for (i=0; i<6; i++) mvwprintw(Humanhand, 2, 5*i, cardname(hand[1][i]));
  1417. X    mvwprintw(Programhand, 2, 0, "\n");
  1418. X    mvwprintw(Humanhand, 0, 0, "\n");
  1419. X    werase(Cut);
  1420. X    werase(Crib);
  1421. X    werase(Pscore);
  1422. X    werase(Hscore);
  1423. X    werase(Select);
  1424. X    wrefresh(Cut);
  1425. X    wrefresh(Crib);
  1426. X    wrefresh(Pscore);
  1427. X    wrefresh(Hscore);
  1428. X    wrefresh(Select);
  1429. X    wrefresh(Programhand);
  1430. X    wrefresh(Humanhand);
  1431. X}
  1432. X
  1433. Xshowfour()
  1434. X{
  1435. X    int i;
  1436. X    werase(Humanhand);
  1437. X    for (i=0; i<4; i++) mvwprintw(Humanhand, 2, 5*i, cardname(hand[1][i]));
  1438. X    waddch(Humanhand,'\n');
  1439. X    for (i=2; i<4; i++) mvwprintw(Crib, 0, 5*i, "XXX  ");
  1440. X    for (i=0; i<4; i++) mvwaddch(Select, 0, 5*i+2, 'a'+i);
  1441. X
  1442. X    wrefresh(Humanhand);
  1443. X    wrefresh(Crib);
  1444. X    wrefresh(Select);
  1445. X}
  1446. X
  1447. Xshowpplay(who, i, scored)
  1448. Xint who, i, scored;
  1449. X{
  1450. X    mvwprintw(Programhand, 0, 5*i, "   ");
  1451. X    mvwprintw(Programhand, 2, 5*(3-nleft[who]), cardname(hand[who][i]));
  1452. X    if (scored) mvwprintw(Prompt, 0, 0, "%d for %d.\n", count, scored);
  1453. X    else mvwprintw(Prompt, 0, 0, "%d.\n", count);
  1454. X    wrefresh(Programhand);
  1455. X    wrefresh(Prompt);
  1456. X    sleep(2);
  1457. X}
  1458. X
  1459. Xshowhplay(i, scored)
  1460. Xint i, scored;
  1461. X{
  1462. X    mvwprintw(Humanhand, 2, 5*i, "   ");
  1463. X    mvwprintw(Humanhand, 0, 5*(3-nleft[1]), cardname(hand[1][i]));
  1464. X    if (scored) mvwprintw(Prompt, 0, 0, "%d for %d.\n", count, scored);
  1465. X    else mvwprintw(Prompt, 0, 0, "%d.\n", count);
  1466. X    wrefresh(Humanhand);
  1467. X    wrefresh(Prompt);
  1468. X}
  1469. X
  1470. Xshowcut()
  1471. X{
  1472. X    mvwprintw(Prompt, 0, 0, playertype[dealer]==HUMAN? "I cut:\n":
  1473. X        "You cut:\n");
  1474. X    mvwaddch(Prompt, 1, 0, '\n');
  1475. X    wrefresh(Prompt);
  1476. X    sleep(1);
  1477. X    mvwprintw(Prompt, 1, 0, "the %s of %s\n",
  1478. X        rankname[RANK(cut)], suitname[SUIT(cut)]);
  1479. X    mvwprintw(Cut, 0, 0, cardname(cut));
  1480. X    wrefresh(Prompt);
  1481. X    wrefresh(Cut);
  1482. X    sleep(1);
  1483. X}
  1484. X
  1485. Xexposecrib()
  1486. X{
  1487. X    int i;
  1488. X    for (i=0; i<6; i++) mvwprintw(Crib, 0, 5*i, cardname(crib[i]));
  1489. X    wrefresh(Crib);
  1490. X    sleep(1);
  1491. X}
  1492. END_OF_show.c
  1493. if test 2076 -ne `wc -c <show.c`; then
  1494.     echo shar: \"show.c\" unpacked with wrong size!
  1495. fi
  1496. # end of overwriting check
  1497. fi
  1498. if test -f shuf.c -a "${1}" != "-c" ; then 
  1499.   echo shar: Will not over-write existing file \"shuf.c\"
  1500. else
  1501. echo shar: Extracting \"shuf.c\" \(811 characters\)
  1502. sed "s/^X//" >shuf.c <<'END_OF_shuf.c'
  1503. X/*
  1504. X *    shuf - shuffle the pack.
  1505. X */
  1506. X
  1507. X#include "defs.h"
  1508. X#include "globs.h"
  1509. X
  1510. X#ifdef    BSD
  1511. Xint    srand();
  1512. Xint    rand();
  1513. X#else
  1514. Xvoid    srand48();
  1515. Xdouble    drand48();
  1516. X#endif
  1517. X
  1518. Xstatic    makepack();
  1519. X
  1520. Xvoid
  1521. Xshuf()
  1522. X{
  1523. X    int j, k;
  1524. X    CARD dummy;
  1525. X    if (!packmade) makepack();
  1526. X    for (j=51; j>=39; j--) {
  1527. X        k = randint(j+1);
  1528. X        dummy = pack[k];
  1529. X        pack[k] = pack[j];
  1530. X        pack[j] = dummy;
  1531. X    }
  1532. X}
  1533. X
  1534. Xstatic
  1535. Xmakepack()
  1536. X{
  1537. X    int suit, rank;
  1538. X    CARD *packp;
  1539. X    packp = pack;
  1540. X    for (suit=CLUB; suit<=SPADE; suit++)
  1541. X    for (rank=ACE; rank<=KING; rank++)
  1542. X        *packp++ = MAKECARD(rank,suit);
  1543. X}
  1544. X
  1545. Xinitrand()
  1546. X{
  1547. X    long time();
  1548. X#ifdef    BSD
  1549. X    srand(time((long *)0));
  1550. X    rand();
  1551. X#else
  1552. X    srand48(time((long *)0));
  1553. X    drand48();
  1554. X#endif
  1555. X}
  1556. X
  1557. X/*
  1558. X *    Returns a random integer from 0 to n-1.
  1559. X */
  1560. Xint
  1561. Xrandint(n)
  1562. Xint n;
  1563. X{
  1564. X#ifdef    BSD
  1565. X    return (rand()/3) % n;
  1566. X#else
  1567. X    return (int)(drand48()*n);
  1568. X#endif
  1569. X}
  1570. END_OF_shuf.c
  1571. if test 811 -ne `wc -c <shuf.c`; then
  1572.     echo shar: \"shuf.c\" unpacked with wrong size!
  1573. fi
  1574. # end of overwriting check
  1575. fi
  1576. if test -f version.c -a "${1}" != "-c" ; then 
  1577.   echo shar: Will not over-write existing file \"version.c\"
  1578. else
  1579. echo shar: Extracting \"version.c\" \(24 characters\)
  1580. sed "s/^X//" >version.c <<'END_OF_version.c'
  1581. Xchar    version[] = "1.1";
  1582. END_OF_version.c
  1583. if test 24 -ne `wc -c <version.c`; then
  1584.     echo shar: \"version.c\" unpacked with wrong size!
  1585. fi
  1586. # end of overwriting check
  1587. fi
  1588. if test -f wglobs.c -a "${1}" != "-c" ; then 
  1589.   echo shar: Will not over-write existing file \"wglobs.c\"
  1590. else
  1591. echo shar: Extracting \"wglobs.c\" \(167 characters\)
  1592. sed "s/^X//" >wglobs.c <<'END_OF_wglobs.c'
  1593. X#include <curses.h>
  1594. X
  1595. XWINDOW    *Crib;
  1596. XWINDOW    *Select;
  1597. XWINDOW    *Board;
  1598. XWINDOW    *Cut;
  1599. XWINDOW    *Hscore;
  1600. XWINDOW    *Humanhand;
  1601. XWINDOW    *Programhand;
  1602. XWINDOW    *Prompt;
  1603. XWINDOW    *Pscore;
  1604. END_OF_wglobs.c
  1605. if test 167 -ne `wc -c <wglobs.c`; then
  1606.     echo shar: \"wglobs.c\" unpacked with wrong size!
  1607. fi
  1608. # end of overwriting check
  1609. fi
  1610. if test -f window.c -a "${1}" != "-c" ; then 
  1611.   echo shar: Will not over-write existing file \"window.c\"
  1612. else
  1613. echo shar: Extracting \"window.c\" \(690 characters\)
  1614. sed "s/^X//" >window.c <<'END_OF_window.c'
  1615. X#include "defs.h"
  1616. X#include "globs.h"
  1617. X#include "window.h"
  1618. X
  1619. Xinitwins()
  1620. X{
  1621. X    initscr();
  1622. X    Humanhand = subwin(stdscr, 3, 29, 16, 30);
  1623. X    Programhand = subwin(stdscr, 3, 28, 5, 30);
  1624. X    Prompt = subwin(stdscr, 2, 72, 22, 5);
  1625. X    Select = subwin(stdscr, 1, 28, 19, 30);
  1626. X    Crib = subwin(stdscr, 1, 20, 12, 1);
  1627. X    Cut = subwin(stdscr, 1, 3, 12, 66);
  1628. X    Hscore = subwin(stdscr, 5, 27, 15, 0);
  1629. X    Pscore = subwin(stdscr, 5, 27, 2, 0);
  1630. X    scrollok(Hscore, TRUE);
  1631. X    scrollok(Pscore, TRUE);
  1632. X    Board = subwin(stdscr, 3, 37, 11, 28);
  1633. X    initboard();
  1634. X}
  1635. X
  1636. Xinitboard()
  1637. X{
  1638. X    int i;
  1639. X    for (i=0; i<37; i++) if (1 != (i%6)) {
  1640. X        mvwaddch(Board, 0, i, ':');
  1641. X        mvwaddch(Board, 2, i, ':');
  1642. X    }
  1643. X}
  1644. X
  1645. Xtermwins()
  1646. X{
  1647. X    clear();
  1648. X    refresh();
  1649. X    endwin();
  1650. X}
  1651. END_OF_window.c
  1652. if test 690 -ne `wc -c <window.c`; then
  1653.     echo shar: \"window.c\" unpacked with wrong size!
  1654. fi
  1655. # end of overwriting check
  1656. fi
  1657. if test -f window.h -a "${1}" != "-c" ; then 
  1658.   echo shar: Will not over-write existing file \"window.h\"
  1659. else
  1660. echo shar: Extracting \"window.h\" \(229 characters\)
  1661. sed "s/^X//" >window.h <<'END_OF_window.h'
  1662. X#include <curses.h>
  1663. Xextern    WINDOW    *Crib;
  1664. Xextern    WINDOW    *Board;
  1665. Xextern    WINDOW    *Select;
  1666. Xextern    WINDOW    *Cut;
  1667. Xextern    WINDOW    *Hscore;
  1668. Xextern    WINDOW    *Humanhand;
  1669. Xextern    WINDOW    *Programhand;
  1670. Xextern    WINDOW    *Prompt;
  1671. Xextern    WINDOW    *Pscore;
  1672. END_OF_window.h
  1673. if test 229 -ne `wc -c <window.h`; then
  1674.     echo shar: \"window.h\" unpacked with wrong size!
  1675. fi
  1676. # end of overwriting check
  1677. fi
  1678. echo shar: End of archive 1 \(of 1\).
  1679. cp /dev/null ark1isdone
  1680. MISSING=""
  1681. for I in 1 ; do
  1682.     if test ! -f ark${I}isdone ; then
  1683.     MISSING="${MISSING} ${I}"
  1684.     fi
  1685. done
  1686. if test "${MISSING}" = "" ; then
  1687.     echo You have unpacked all 1 archives.
  1688.     rm -f ark[1-9]isdone
  1689. else
  1690.     echo You still need to unpack the following archives:
  1691.     echo "        " ${MISSING}
  1692. fi
  1693. ##  End of shell archive.
  1694. exit 0
  1695.